DEFINITION MODULE  MEMORY;

(*****************************************************************************)
(* Die in diesem Modul enthaltenen Prozeduren dienen der direkten Manipula-  *)
(* tion groesserer Speicherbereiche. Vor allem solcher, deren Groesse erst   *)
(* zur Laufzeit feststeht ( z.B. offene ARRAY-Parameter ). Die Anfangsadres- *)
(* sen der Speicherbereiche koennen sowohl gerade als auch ungerade sein.    *)
(* Wenn allerdings bei einer Prozedur, die zwei Speicherbereiche benoetigt,  *)
(* der eine an ungerader, der andere an gerader Adresse beginnt, sinkt die   *)
(* Geschwindigkeit deutlich ab - die Routinen brauchen mehr als doppelt so   *)
(* lang ( es wird nur byteweise kopiert, sonst langwortweise ).              *)
(*___________________________________________________________________________*)
(*  07-Feb-90 , Holger Kleinschmidt                                          *)
(*****************************************************************************)

FROM  SYSTEM  IMPORT (* TYPE *)  ADDRESS;

(*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*)

TYPE  CopyProc = PROCEDURE ((* EIN  quelle *) ADDRESS,
                            (* EIN  ziel   *) ADDRESS,
                            (* EIN  laenge *) CARDINAL );

(*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*)

PROCEDURE  ClearMem ((* EIN/ -- *)  start  : ADDRESS;
                     (* EIN/ -- *)  laenge : CARDINAL );

(*--------------------------------------------------------------------------
 | Diese Prozedur ueberschreibt einen Speicherbereich von <laenge> Bytes    |
 | beginnend bei Adresse <start> mit Nullbytes.                             |
 |  - Ist <laenge> = Null, passiert nichts                                  |
  --------------------------------------------------------------------------*)


PROCEDURE  FillMem ((* EIN/ -- *)  start  : ADDRESS;
                    (* EIN/ -- *)  laenge : CARDINAL;
                    (* EIN/ -- *)  muster : LONGCARD );

(*--------------------------------------------------------------------------
 | Diese Prozedur fuellt einen Speicherbereich von <laenge> Bytes beginnend |
 | bei Adresse <start> mit dem <muster>. Da <muster> ein  LONGCARD-Wert ist,|
 | lassen sich Muster bis zu einer Laenge von vier Bytes benutzen. Soll das |
 | Muster alle zwei Bytes wiederholt werden, so uebergibt man eben als      |
 | <muster> das Muster zweimal hintereinander, soll das Muster nur ein Byte |
 | Laenge haben, so uebergibt man vier gleiche Bytes hintereinander.        |
 |                                                                          |
 | Beispiel: 4-Byte-Muster  <muster>   = 0FEDCBA98H                         |
 |           2-Byte-Muster     "       =  12341234H                         |
 |           1-Byte-Muster     "       =  5A5A5A5AH                         |
 |                                                                          |
 | Ein 2- oder 4-Byte-Muster kann auch an einer ungeraden Adr. beginnen !   |
 |  - Ist <laenge> = Null, passiert nichts                                  |
  --------------------------------------------------------------------------*)


PROCEDURE  CopyMem ((* EIN/ -- *)  quelle,
                    (* EIN/ -- *)  ziel   : ADDRESS;
                    (* EIN/ -- *)  laenge : CARDINAL );

(*--------------------------------------------------------------------------
 | Die Prozedur kopiert <laenge> Bytes des Speicherbereiches ab der Adresse |
 | <quelle> in den Speicherbereich ab der Adresse <ziel>. Die Speicherbe-   |
 | reiche duerfen sich ueberlappen.                                         |
 |  - Ist <laenge> = Null, passiert nichts                                  |
  --------------------------------------------------------------------------*)

PROCEDURE  CopySmallMem ((* EIN/ -- *)  quelle,
                         (* EIN/ -- *)  ziel   : ADDRESS;
                         (* EIN/ -- *)  laenge : CARDINAL );

(*--------------------------------------------------------------------------
 | Dies ist eine schnelle Variante von "CopyMem" fuer 'kleine' Speicherbe-  |
 | reiche ( ~ bis 10 Bytes ). Die Speicherbereiche duerfen sich NICHT ueber-|
 | lappen. Diese Routine kann man also benutzen, wenn wahrscheinlich ist,   |
 | dass nur Standardtypen kopiert werden, aber kein bestimmter festliegt.   |
  --------------------------------------------------------------------------*)


PROCEDURE  SwapMem ((* EIN/ -- *)  block1,
                    (* EIN/ -- *)  block2 : ADDRESS;
                    (* EIN/ -- *)  laenge : CARDINAL );

(*--------------------------------------------------------------------------
 | Die Prozedur tauscht <laenge> Bytes der beiden Speicherbereiche ab den   |
 | Adressen <block1> und <block2> gegeneinander aus.                        |
 | Diese Prozedur wird z.B. von Sortierroutinen benoetigt.                  |
 |  - Ist <laenge> = Null, passiert nichts                                  |
  --------------------------------------------------------------------------*)


PROCEDURE  EqualMem ((* EIN/ -- *)  block1,
                     (* EIN/ -- *)  block2 : ADDRESS;
                     (* EIN/ -- *)  laenge : CARDINAL ): BOOLEAN;

(*--------------------------------------------------------------------------
 | Die Funktion vergleicht <laenge> Bytes der beiden Speicherbereiche ab den|
 | Adressen <block1> und <block2> miteinander. Sind alle Bytes der beiden   |
 | Bloecke gleich, wird TRUE zurueckgeliefert, sonst FALSE                  |
 |  - Ist <laenge> = Null, wird TRUE zurueckgeliefert                       |
  --------------------------------------------------------------------------*)

END  MEMORY.
